9x9 AI Escargot 2006.txt

Order 3: digits 9; houses 27, cells 81.

Grid.grid1: initial copying

pending={a1, a6, a8, b2, b5, b9, c3, c4, c7, d3, d4, d7, e2, e5, e9, f1, f6, g1, g8, h2, h9, i3, i7}

deduce.grid1: naked-singles

deduce.grid1: hidden-singles

deduce.grid1.col3. h3 is 1 by hidden-single.

pending={h3}

deduce.grid1: naked-singles

deduce.grid1: hidden-singles

deduce.grid1: naked-pairs

two's heap=e3 {3|4}, b3 {4|6}.

grid1
1 2 3 4 5 6 7 8 9
a 1
 2 
 56
 8 
 2 
4 6
 8 
   
45 
 8 
  3
45 
   
7
 2 
4 6
   
9
  3
4 6
   
b
   
45 
7  
3
   
4 6
   
1  
45 
  9
2
1  
 5 
  9
1  
4 6
7  
   
4 6
7  
8
c
 2 
4  
78 
 2 
   
78 
9 6
1 3
4  
   
1 3
   
 8 
5
 23
4  
7  
1 3
4  
   
d
 2 
4  
78 
 2 
   
78 
5 3
1  
  6
7  
12 
  6
   
9
   
4 6
78 
1  
4 6
   
e
   
4  
7 9
1
  3
4  
   
   
 5 
7 9
8
   
 56
  9
   
4 6
7  
  3
456
7  
2
f 6
 2 
   
789
 23
   
 8 
12 
 5 
7 9
1  
 5 
7 9
4
1  
   
78 
  3
 5 
78 
1 3
 5 
   
g 3
 2 
 56
 89
 2 
  6
 8 
 2 
45 
789
   
456
7 9
 2 
 56
 89
 2 
4 6
 8 
1
   
456
  9
h
 2 
 5 
 89
4 1
 2 
 5 
 89
  3
 56
  9
 23
 56
 89
 2 
  6
 8 
 2 
 56
 8 
7
i
 2 
 5 
 89
 2 
 56
 89
7
12 
45 
 89
1  
456
  9
12 
 56
 89
3
 2 
456
 8 
   
456
  9

backtrack.grid1 → grid2: b3 guess 4 ∈ {4|6}

pending={b3}

deduce.grid2: naked-singles

deduce.grid2: hidden-singles

deduce.grid2: naked-pairs

two's heap=b1 {5|7}, b8 {6|7}, f3 {2|8}.

grid2
1 2 3 4 5 6 7 8 9
a 1
 2 
 56
 8 
 2 
  6
 8 
   
45 
 8 
  3
45 
   
7
 2 
4 6
   
9
  3
4 6
   
b
   
 5 
7  
3 4
1  
 5 
  9
2
1  
 5 
  9
1  
  6
7  
   
  6
7  
8
c
 2 
   
78 
 2 
   
78 
9 6
1 3
4  
   
1 3
   
 8 
5
 23
4  
7  
1 3
4  
   
d
 2 
4  
78 
 2 
   
78 
5 3
1  
  6
7  
12 
  6
   
9
   
4 6
78 
1  
4 6
   
e
   
4  
7 9
1 3
   
 5 
7 9
8
   
 56
  9
   
4 6
7  
   
456
7  
2
f 6
 2 
   
789
 2 
   
 8 
12 
 5 
7 9
1  
 5 
7 9
4
1  
   
78 
  3
 5 
78 
1 3
 5 
   
g 3
 2 
 56
 89
 2 
  6
 8 
 2 
45 
789
   
456
7 9
 2 
 56
 89
 2 
4 6
 8 
1
   
456
  9
h
 2 
 5 
 89
4 1
 2 
 5 
 89
  3
 56
  9
 23
 56
 89
 2 
  6
 8 
 2 
 56
 8 
7
i
 2 
 5 
 89
 2 
 56
 89
7
12 
45 
 89
1  
456
  9
12 
 56
 89
3
 2 
456
 8 
   
456
  9

backtrack.grid2 → grid3: b1 guess 5 ∈ {5|7}

pending={b1}

deduce.grid3: naked-singles

deduce.grid3: hidden-singles

deduce.grid3: naked-pairs

two's heap=b8 {6|7}, f3 {2|8}, b4 {1|9}, b6 {1|9}.

Naked-pair {1|9} in cells {b4, b6} contained within {rowb, box2}, updating cells {a4, a5, b7, b8, c5, c6}:

grid3
1 2 3 4 5 6 7 8 9
a 1
 2 
  6
 8 
 2 
  6
 8 
   
45 
 8 
  3
45 
   
7
 2 
4 6
   
9
  3
4 6
   
b 5 3 4
1  
   
  9
2
1  
   
  9
   
  6
7  
   
  6
7  
8
c
 2 
   
78 
 2 
   
78 
9 6
  3
4  
   
  3
   
 8 
5
 23
4  
7  
1 3
4  
   
d
 2 
4  
78 
 2 
   
78 
5 3
1  
  6
7  
12 
  6
   
9
   
4 6
78 
1  
4 6
   
e
   
4  
7 9
1 3
   
 5 
7 9
8
   
 56
  9
   
4 6
7  
   
456
7  
2
f 6
 2 
   
789
 2 
   
 8 
12 
 5 
7 9
1  
 5 
7 9
4
1  
   
78 
  3
 5 
78 
1 3
 5 
   
g 3
 2 
 56
 89
 2 
  6
 8 
 2 
45 
789
   
456
7 9
 2 
 56
 89
 2 
4 6
 8 
1
   
456
  9
h
 2 
   
 89
4 1
 2 
 5 
 89
  3
 56
  9
 23
 56
 89
 2 
  6
 8 
 2 
 56
 8 
7
i
 2 
   
 89
 2 
 56
 89
7
12 
45 
 89
1  
456
  9
12 
 56
 89
3
 2 
456
 8 
   
456
  9

backtrack.grid3 → grid4: b4 guess 1 ∈ {1|9}

pending={b4}

deduce.grid4: naked-singles

deduce.grid4: hidden-singles

deduce.grid4.rowc. c9 is 1 by hidden-single.

pending={c9}

deduce.grid4: naked-singles

deduce.grid4: hidden-singles

deduce.grid4.col7. f7 is 1 by hidden-single.

pending={f7}

deduce.grid4: naked-singles

deduce.grid4: hidden-singles

deduce.grid4: naked-pairs

two's heap=c5 {3|4}, f9 {3|5}, e6 {5|6}, d9 {4|6}, b8 {6|7}, b7 {6|7}, f3 {2|8}, c6 {3|8}.

Naked-pair {6|7} in cells {b7, b8} contained within {rowb, box3}, updating cells {a7, a9, c8}:

grid4
1 2 3 4 5 6 7 8 9
a 1
 2 
  6
 8 
 2 
  6
 8 
   
45 
 8 
  3
45 
   
7
 2 
4  
   
9
  3
4  
   
b 5 3 4 1 2 9
   
  6
7  
   
  6
7  
8
c
 2 
   
78 
 2 
   
78 
9 6
  3
4  
   
  3
   
 8 
5
 23
4  
   
1
d
 2 
4  
78 
 2 
   
78 
5 3
1  
  6
7  
12 
  6
   
9
   
4 6
78 
   
4 6
   
e
   
4  
7 9
1 3
   
 5 
7 9
8
   
 56
   
   
4 6
7  
   
456
7  
2
f 6
 2 
   
789
 2 
   
 8 
 2 
 5 
7 9
   
 5 
7 9
4 1
  3
 5 
78 
  3
 5 
   
g 3
 2 
 56
 89
 2 
  6
 8 
 2 
45 
789
   
456
7 9
 2 
 56
 8 
 2 
4 6
 8 
1
   
456
  9
h
 2 
   
 89
4 1
 2 
 5 
 89
  3
 56
  9
 23
 56
 8 
 2 
  6
 8 
 2 
 56
 8 
7
i
 2 
   
 89
 2 
 56
 89
7
 2 
45 
 89
1  
456
  9
12 
 56
 8 
3
 2 
456
 8 
   
456
  9

backtrack.grid4 → grid5: a7 guess 2 ∈ {2|4}

pending={a7}

deduce.grid5: naked-singles

deduce.grid5: hidden-singles

deduce.grid5: naked-pairs

two's heap=a9 {3|4}, c8 {3|4}, c5 {3|4}, d9 {4|6}, e6 {5|6}, f9 {3|5}, c6 {3|8}, a3 {6|8}, b7 {6|7}, b8 {6|7}, f3 {2|8}, a2 {6|8}, h7 {6|8}.

Naked-pair {3|4} in cells {a9, c5, c8} contained within {rowc, box3}, updating cells {b7, b8, c1, c2, c6}:

Naked-pair {6|7} in cells {b7, b8} contained within {rowb, box3}, updating cells {a9, c8}:

Naked-pair {6|8} in cells {a2, a3, h7} contained within {rowa, box1}, updating cells {a4, a5, a9, c1, c2}:

pending={c6}

deduce.grid5: naked-singles

deduce.grid5: hidden-singles

deduce.grid5.col6. h6 is 3 by hidden-single.

pending={h6}

deduce.grid5: naked-singles

deduce.grid5: hidden-singles

deduce.grid5: naked-pairs

two's heap=a9 {3|4}, c5 {3|4}, f9 {3|5}, a4 {4|5}, c8 {3|4}, c1 {2|7}, e6 {5|6}, a3 {6|8}, c2 {2|7}, b7 {6|7}, d9 {4|6}, a2 {6|8}, f3 {2|8}, b8 {6|7}, h7 {6|8}.

Naked-pair {3|4} in cells {a9, c5, c8} contained within {rowc, box3}, updating cells {b7, b8, c1, c2}:

Naked-pair {2|7} in cells {c1, c2} contained within {rowc, box1}, updating cells {a2, a3, c5, c8}:

Naked-pair {6|7} in cells {b7, b8} contained within {rowb, box3}, updating cells {a9, c8}:

Naked-pair {6|8} in cells {a2, a3, h7} contained within {rowa, box1}, updating cells {a4, a5, a9, c1, c2}:

grid5
1 2 3 4 5 6 7 8 9
a 1
   
  6
 8 
   
  6
 8 
   
45 
   
  3
45 
   
7 2 9
  3
4  
   
b 5 3 4 1 2 9
   
  6
7  
   
  6
7  
8
c
 2 
   
7  
 2 
   
7  
9 6
  3
4  
   
8 5
  3
4  
   
1
d
 2 
4  
78 
 2 
   
78 
5 3
1  
  6
7  
12 
  6
   
9
   
4 6
78 
   
4 6
   
e
   
4  
7 9
1 3
   
 5 
7 9
8
   
 56
   
   
4 6
7  
   
456
7  
2
f 6
 2 
   
789
 2 
   
 8 
 2 
 5 
7 9
   
 5 
7 9
4 1
  3
 5 
78 
  3
 5 
   
g 3
 2 
 56
 89
 2 
  6
 8 
 2 
45 
789
   
456
7 9
 2 
 56
   
   
4 6
 8 
1
   
456
  9
h
 2 
   
 89
4 1
 2 
 5 
 89
   
 56
  9
3
   
  6
 8 
 2 
 56
 8 
7
i
 2 
   
 89
 2 
 56
 89
7
 2 
45 
 89
1  
456
  9
12 
 56
   
3
 2 
456
 8 
   
456
  9

backtrack.grid5 → grid6: a2 guess 6 ∈ {6|8}

pending={a2}

deduce.grid6: naked-singles

deduce.grid6: hidden-singles

deduce.grid6.rowd. d6 is 2 by hidden-single.

pending={d6}

deduce.grid6: naked-singles

deduce.grid6: hidden-singles

deduce.grid6.rowd. d5 is 1 by hidden-single.

pending={d5}

deduce.grid6: naked-singles

deduce.grid6: hidden-singles

deduce.grid6.rowh. h8 is 5 by hidden-single.

pending={h8}

deduce.grid6: naked-singles

deduce.grid6: hidden-singles

deduce.grid6.rowe. e4 is 5 by hidden-single.

pending={e4}

deduce.grid6: naked-singles

grid6 didn't work: naked-singles ran out of candidates.

…backtrack.grid5 again

backtrack.grid5 → grid7: a2 guess 8 ∈ {6|8}

pending={a2}

deduce.grid7: naked-singles

deduce.grid7: hidden-singles

deduce.grid7: naked-pairs

two's heap=a9 {3|4}, c8 {3|4}, c5 {3|4}, a4 {4|5}, d9 {4|6}, f9 {3|5}, c2 {2|7}, b8 {6|7}, d2 {2|7}, c1 {2|7}, e6 {5|6}, f3 {2|8}, b7 {6|7}, g3 {2|8}, h7 {6|8}.

Naked-pair {3|4} in cells {a9, c5, c8} contained within {rowc, box3}, updating cells {b7, b8, c1, c2}:

Naked-pair {2|7} in cells {c1, c2, d2} contained within {rowc, col2, box1}, updating cells {c5, c8, f2, g2, i2}:

Naked-pair {6|7} in cells {b7, b8} contained within {rowb, box3}, updating cells {a9, c8}:

pending={f2}

deduce.grid7: naked-singles

deduce.grid7: hidden-singles

deduce.grid7.rowe. e4 is 9 by hidden-single.

pending={e4}

deduce.grid7: naked-singles

deduce.grid7: hidden-singles

deduce.grid7: naked-pairs

two's heap=a9 {3|4}, c8 {3|4}, c5 {3|4}, a4 {4|5}, d9 {4|6}, e6 {5|6}, f9 {3|5}, g2 {5|6}, i2 {5|6}, c1 {2|7}, e1 {4|7}, b7 {6|7}, f3 {2|8}, f5 {5|7}, c2 {2|7}, b8 {6|7}, g3 {2|8}, h7 {6|8}, d2 {2|7}.

Naked-pair {3|4} in cells {a9, c5, c8} contained within {rowc, box3}, updating cells {b7, b8, c1, c2}:

Naked-pair {5|6} in cells {e6, g2, i2} contained within {col2, box7}, updating cells {c2, d2, g3, h1, i1}:

Naked-pair {2|7} in cells {c1, c2, d2} contained within {rowc, col2, box1}, updating cells {c5, c8, g2, i2}:

Naked-pair {6|7} in cells {b7, b8} contained within {rowb, box3}, updating cells {a9, c8}:

grid7
1 2 3 4 5 6 7 8 9
a 1 8 6
   
45 
   
  3
45 
   
7 2 9
  3
4  
   
b 5 3 4 1 2 9
   
  6
7  
   
  6
7  
8
c
 2 
   
7  
 2 
   
7  
9 6
  3
4  
   
8 5
  3
4  
   
1
d
 2 
4  
78 
 2 
   
7  
5 3
1  
  6
7  
12 
  6
   
9
   
4 6
78 
   
4 6
   
e
   
4  
7  
1 3 9 8
   
 56
   
   
4 6
7  
   
456
7  
2
f 6 9
 2 
   
 8 
 2 
 5 
7  
   
 5 
7  
4 1
  3
 5 
78 
  3
 5 
   
g 3
   
 56
   
 2 
   
 8 
 2 
45 
78 
   
456
7 9
 2 
 56
   
   
4 6
 8 
1
   
456
  9
h
 2 
   
 89
4 1
 2 
 5 
 8 
   
 56
  9
3
   
  6
 8 
 2 
 56
 8 
7
i
 2 
   
 89
   
 56
   
7
 2 
45 
 8 
1  
456
  9
12 
 56
   
3
 2 
456
 8 
   
456
  9

backtrack.grid7 → grid8: a4 guess 4 ∈ {4|5}

pending={a4}

deduce.grid8: naked-singles

deduce.grid8: hidden-singles

deduce.grid8.rowd. d8 is 8 by hidden-single.

pending={d8}

deduce.grid8: naked-singles

deduce.grid8: hidden-singles

deduce.grid8.rowe. e6 is 5 by hidden-single.

pending={e6}

deduce.grid8: naked-singles

grid8 didn't work: naked-singles ran out of candidates.

…backtrack.grid7 again

backtrack.grid7 → grid9: a4 guess 5 ∈ {4|5}

pending={a4}

deduce.grid9: naked-singles

deduce.grid9: hidden-singles

deduce.grid9: naked-pairs

two's heap=a5 {3|4}, a9 {3|4}, c5 {3|4}, c8 {3|4}, d9 {4|6}, e6 {5|6}, c2 {2|7}, f9 {3|5}, d2 {2|7}, i2 {5|6}, e1 {4|7}, b7 {6|7}, f3 {2|8}, f4 {2|7}, f5 {5|7}, b8 {6|7}, g2 {5|6}, g3 {2|8}, h4 {2|8}, h7 {6|8}, c1 {2|7}.

Naked-pair {3|4} in cells {a5, a9, c5, c8} contained within {rowa, rowc, col5, box2, box3}, updating cells {b7, b8, c1, c2, d5, f5, g5, h5, i5}:

Naked-pair {5|6} in cells {e6, g2, i2} contained within {col2, box7}, updating cells {c2, d2, g3, h1, i1}:

Naked-pair {2|7} in cells {c1, c2, d2, f4} contained within {rowc, col2, box1}, updating cells {c5, c8, g2, i2}:

Naked-pair {6|7} in cells {b7, b8} contained within {rowb, box3}, updating cells {a9, c8}:

grid9
1 2 3 4 5 6 7 8 9
a 1 8 6 5
  3
4  
   
7 2 9
  3
4  
   
b 5 3 4 1 2 9
   
  6
7  
   
  6
7  
8
c
 2 
   
7  
 2 
   
7  
9 6
  3
4  
   
8 5
  3
4  
   
1
d
 2 
4  
78 
 2 
   
7  
5 3
1  
  6
7  
12 
  6
   
9
   
4 6
78 
   
4 6
   
e
   
4  
7  
1 3 9 8
   
 56
   
   
4 6
7  
   
456
7  
2
f 6 9
 2 
   
 8 
 2 
   
7  
   
 5 
7  
4 1
  3
 5 
78 
  3
 5 
   
g 3
   
 56
   
 2 
   
 8 
 2 
4  
78 
   
 56
7 9
 2 
 56
   
   
4 6
 8 
1
   
456
  9
h
 2 
   
 89
4 1
 2 
   
 8 
   
 56
  9
3
   
  6
 8 
 2 
 56
 8 
7
i
 2 
   
 89
   
 56
   
7
 2 
4  
 8 
1  
 56
  9
12 
 56
   
3
 2 
456
 8 
   
456
  9

backtrack.grid9 → grid10: a5 guess 3 ∈ {3|4}

pending={a5}

deduce.grid10: naked-singles

deduce.grid10: hidden-singles

deduce.grid10.rowe. e6 is 6 by hidden-single.

pending={e6}

deduce.grid10: naked-singles

deduce.grid10: hidden-singles

deduce.grid10.rowe. e8 is 5 by hidden-single.

pending={e8}

deduce.grid10: naked-singles

deduce.grid10: hidden-singles

deduce.grid10.rowf. f5 is 5 by hidden-single.

pending={f5}

deduce.grid10: naked-singles

deduce.grid10: hidden-singles

grid10 didn't work: rowh is not bijective.

…backtrack.grid9 again

backtrack.grid9 → grid11: a5 guess 4 ∈ {3|4}

pending={a5}

deduce.grid11: naked-singles

grid11 didn't work: naked-singles ran out of candidates.

…backtrack.grid9 again

grid9 didn't work: exhaustive search revealed no solution.

…backtrack.grid7 again

grid7 didn't work: exhaustive search revealed no solution.

…backtrack.grid5 again

grid5 didn't work: exhaustive search revealed no solution.

…backtrack.grid4 again

backtrack.grid4 → grid12: a7 guess 4 ∈ {2|4}

pending={a7}

deduce.grid12: naked-singles

deduce.grid12: hidden-singles

deduce.grid12.rowf. f8 is 3 by hidden-single.

pending={f8}

deduce.grid12: naked-singles

deduce.grid12: hidden-singles

deduce.grid12.rowh. h5 is 3 by hidden-single.

pending={h5}

deduce.grid12: naked-singles

deduce.grid12: hidden-singles

deduce.grid12.box6. d8 is 8 by hidden-single.

pending={d8}

deduce.grid12: naked-singles

deduce.grid12: hidden-singles

deduce.grid12: naked-pairs

two's heap=a2 {2|6}, a3 {2|6}, h8 {5|6}, d9 {4|6}, e7 {6|7}, d2 {2|7}, b7 {6|7}, b8 {6|7}, e6 {5|6}, c1 {7|8}, f3 {2|8}, f5 {7|9}, c2 {7|8}.

Naked-pair {2|6} in cells {a2, a3} contained within {rowa, box1}, updating cells {c1, c2}:

Naked-pair {6|7} in cells {b7, b8, e7} contained within {rowb, col7, box3}, updating cells {g7, h7}:

Naked-pair {7|8} in cells {c1, c2} contained within {rowc, box1}, updating cells {a2, a3}:

grid12
1 2 3 4 5 6 7 8 9
a 1
 2 
  6
   
 2 
  6
   
8 5 7 4 9 3
b 5 3 4 1 2 9
   
  6
7  
   
  6
7  
8
c
   
   
78 
   
   
78 
9 6 4 3 5 2 1
d
 2 
4  
7  
 2 
   
7  
5 3
1  
  6
7  
12 
  6
   
9 8
   
4 6
   
e
   
4  
7 9
1 3
   
 5 
7 9
8
   
 56
   
   
  6
7  
   
4 6
7  
2
f 6
 2 
   
789
 2 
   
 8 
 2 
   
7 9
   
   
7 9
4 1 3 5
g 3
 2 
 56
 89
 2 
  6
 8 
 2 
45 
7 9
   
  6
7 9
 2 
 56
 8 
 2 
   
 8 
1
   
4 6
  9
h
 2 
   
 89
4 1
 2 
 5 
  9
3
 2 
 56
 8 
 2 
   
 8 
   
 56
   
7
i
 2 
   
 89
 2 
 56
 89
7
 2 
45 
  9
1  
  6
  9
12 
 56
 8 
3
   
456
   
   
4 6
  9

backtrack.grid12 → grid13: a2 guess 2 ∈ {2|6}

pending={a2}

deduce.grid13: naked-singles

deduce.grid13: hidden-singles

deduce.grid13.rowd. d9 is 4 by hidden-single.

pending={d9}

deduce.grid13: naked-singles

deduce.grid13: hidden-singles

deduce.grid13.rowe. e4 is 9 by hidden-single.

pending={e4}

deduce.grid13: naked-singles

grid13 didn't work: naked-singles ran out of candidates.

…backtrack.grid12 again

backtrack.grid12 → grid14: a2 guess 6 ∈ {2|6}

pending={a2}

deduce.grid14: naked-singles

deduce.grid14: hidden-singles

deduce.grid14: naked-pairs

two's heap=d9 {4|6}, b7 {6|7}, e6 {5|6}, e7 {6|7}, b8 {6|7}, h7 {2|8}, h8 {5|6}, c2 {7|8}, f5 {7|9}, g5 {7|9}, g7 {2|8}, g9 {4|9}, c1 {7|8}, d2 {2|7}.

Naked-pair {6|7} in cells {b7, b8, e7} contained within {rowb, col7, box3}, updating cells {g7, h7}:

Naked-pair {2|8} in cells {g7, h7} contained within {col7, box9}, updating cells {b7, e7, g9, h8, i8, i9}:

Naked-pair {7|9} in cells {f5, g5} contained within {col5}, updating cells {d5, i5}:

grid14
1 2 3 4 5 6 7 8 9
a 1 6 2 8 5 7 4 9 3
b 5 3 4 1 2 9
   
  6
7  
   
  6
7  
8
c
   
   
78 
   
   
78 
9 6 4 3 5 2 1
d
 2 
4  
7  
 2 
   
7  
5 3
1  
  6
   
12 
  6
   
9 8
   
4 6
   
e
   
4  
7 9
1 3
   
 5 
7 9
8
   
 56
   
   
  6
7  
   
4 6
7  
2
f 6
 2 
   
7 9
8
 2 
   
7 9
   
   
7 9
4 1 3 5
g 3
 2 
 5 
 89
6
 2 
45 
7 9
   
   
7 9
 2 
 5 
 8 
 2 
   
 8 
1
   
4  
  9
h
 2 
   
 89
4 1
 2 
 5 
  9
3
 2 
 56
 8 
 2 
   
 8 
   
 56
   
7
i
 2 
   
 89
 2 
 5 
 89
7
 2 
45 
  9
1  
  6
   
12 
 56
 8 
3
   
456
   
   
4 6
  9

backtrack.grid14 → grid15: b7 guess 6 ∈ {6|7}

pending={b7}

deduce.grid15: naked-singles

deduce.grid15: hidden-singles

deduce.grid15: naked-pairs

two's heap=d5 {1|6}, i5 {1|6}, h8 {5|6}, d9 {4|6}, d2 {2|7}, c1 {7|8}, g7 {2|8}, e8 {4|6}, e6 {5|6}, f5 {7|9}, g5 {7|9}, e1 {4|9}, g9 {4|9}, e4 {5|9}, h7 {2|8}, c2 {7|8}.

Naked-pair {1|6} in cells {d5, i5} contained within {col5}, updating cells {f5, g5}:

Naked-pair {2|8} in cells {g7, h7} contained within {col7, box9}, updating cells {g9, h8, i8, i9}:

Naked-pair {7|9} in cells {f5, g5} contained within {col5}, updating cells {d5, i5}:

grid15
1 2 3 4 5 6 7 8 9
a 1 6 2 8 5 7 4 9 3
b 5 3 4 1 2 9 6 7 8
c
   
   
78 
   
   
78 
9 6 4 3 5 2 1
d
 2 
4  
7  
 2 
   
7  
5 3
1  
  6
   
12 
  6
   
9 8
   
4 6
   
e
   
4  
  9
1 3
   
 5 
  9
8
   
 56
   
7
   
4 6
   
2
f 6
 2 
   
7 9
8
 2 
   
7 9
   
   
7 9
4 1 3 5
g 3
 2 
 5 
 89
6
 2 
45 
7 9
   
   
7 9
 2 
 5 
 8 
 2 
   
 8 
1
   
4  
  9
h
 2 
   
 89
4 1
 2 
 5 
  9
3
 2 
 56
 8 
 2 
   
 8 
   
 56
   
7
i
 2 
   
 89
 2 
 5 
 89
7
 2 
45 
  9
1  
  6
   
12 
 56
 8 
3
   
456
   
   
4 6
  9

backtrack.grid15 → grid16: c1 guess 7 ∈ {7|8}

pending={c1}

deduce.grid16: naked-singles

deduce.grid16: hidden-singles

deduce.grid16.rowd. d2 is 7 by hidden-single.

pending={d2}

deduce.grid16: naked-singles

deduce.grid16: hidden-singles

deduce.grid16: naked-pairs

two's heap=d1 {2|4}, d5 {1|6}, i5 {1|6}, f2 {2|9}, g7 {2|8}, e6 {5|6}, d9 {4|6}, e1 {4|9}, f5 {7|9}, g5 {7|9}, e4 {5|9}, g9 {4|9}, h7 {2|8}, h8 {5|6}, e8 {4|6}.

Naked-pair {1|6} in cells {d5, i5} contained within {col5}, updating cells {f5, g5}:

Naked-pair {2|8} in cells {g7, h7} contained within {col7, box9}, updating cells {g9, h8, i8, i9}:

Naked-pair {7|9} in cells {f5, g5} contained within {col5}, updating cells {d5, i5}:

grid16
1 2 3 4 5 6 7 8 9
a 1 6 2 8 5 7 4 9 3
b 5 3 4 1 2 9 6 7 8
c 7 8 9 6 4 3 5 2 1
d
 2 
4  
   
7 5 3
1  
  6
   
12 
  6
   
9 8
   
4 6
   
e
   
4  
  9
1 3
   
 5 
  9
8
   
 56
   
7
   
4 6
   
2
f 6
 2 
   
  9
8
 2 
   
7 9
   
   
7 9
4 1 3 5
g 3
 2 
 5 
  9
6
 2 
45 
7 9
   
   
7 9
 2 
 5 
 8 
 2 
   
 8 
1
   
4  
  9
h
 2 
   
 89
4 1
 2 
 5 
  9
3
 2 
 56
 8 
 2 
   
 8 
   
 56
   
7
i
 2 
   
 89
 2 
 5 
  9
7
 2 
45 
  9
1  
  6
   
12 
 56
 8 
3
   
456
   
   
4 6
  9

backtrack.grid16 → grid17: d1 guess 2 ∈ {2|4}

pending={d1}

deduce.grid17: naked-singles

grid17 didn't work: naked-singles ran out of candidates.

…backtrack.grid16 again

backtrack.grid16 → grid18: d1 guess 4 ∈ {2|4}

pending={d1}

deduce.grid18: naked-singles

deduce.grid18. Solved.

grid18
1 2 3 4 5 6 7 8 9
a 1 6 2 8 5 7 4 9 3
b 5 3 4 1 2 9 6 7 8
c 7 8 9 6 4 3 5 2 1
d 4 7 5 3 1 2 9 8 6
e 9 1 3 5 8 6 7 4 2
f 6 2 8 7 9 4 1 3 5
g 3 5 6 4 7 8 2 1 9
h 2 4 1 9 3 5 8 6 7
i 8 9 7 2 6 1 3 5 4

grid18. Copying solution to raw grid.